/**
 * regular.js
 * 正则校验
 * @author HLonlin <1021944439@qq.com>
 */

/* 手机号码 */
export const validateMobilePhone = (value, callback) => {
  if (value) {
    let reg = /^1[3456789]\d{9}$/
    if (!reg.test(value)) {
      return callback(new Error('请输入有效的手机号码'))
    } else {
      callback()
    }
  } else {
    callback()
  }
}

// 校验手机号码和固话
export const mobileAndPhone = (value, callback) => {
  if (value) {
    let mobile = /^1[3456789]\d{9}$/
    let phone = /^0\d{2,3}-?\d{7,8}$/
    if (!mobile.test(value) && !phone.test(value)) {
      return callback(new Error('请输入有效的固话或手机号'))
    } else {
      callback()
    }
  } else {
    callback()
  }
}

/* 判空 */
export const noEmpty = (value, callback) => {
  if (!value) {
    return callback(new Error('有未填写字段！'))
  }
}

// 数字
export const beNumberRules = (value, callback) => {
  if (value) {
    if (isNaN(value)) {
      return callback(new Error('请输入数字值'))
    } else {
      callback()
    }
  } else {
    callback()
  }
}

// 正整数

export const positiveNumber = (value, callback) => {
  if (value === 0 || value) {
    let reg = /(^[1-9]\d*$)/
    if (!reg.test(value)) {
      return callback(new Error('请输入正整数数字'))
    } else {
      callback()
    }
  } else {
    callback()
  }
}
// 必填数字
export const beRequireNumberRules = (value, callback) => {
  if (value) {
    if (isNaN(value)) {
      return callback(new Error('请输入数字值'))
    } else {
      callback()
    }
  } else {
    return callback(new Error('该字段不能为空'))
  }
}
export const checkPrice = (value, callback) => {
  if (value) {
    if (isNaN(value)) {
      return callback(new Error('请输入数字值'))
    } else if (value < 0) {
      return callback(new Error('资费不能为负数'))
    } else {
      callback()
    }
  } else {
    callback()
  }
}
export const checkRequirePrice = (value, callback) => {
  if (value) {
    if (isNaN(value)) {
      return callback(new Error('请输入数字值'))
    } else if (value < 0) {
      return callback(new Error('资费不能为负数'))
    } else {
      callback()
    }
  } else {
    return callback(new Error('该字段不能为空'))
  }
}

/* 非负数或-1 */
export const formateAmount = (value, callback) => {
  if (value) {
    var regPos = /^\d+(\.\d+)?$/ // 非负浮点数
    // var regNeg = /^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/; //负浮点数
    if (value === -1 || regPos.test(value)) {
      callback()
    } else {
      return callback(new Error('请输入-1或非负数'))
    }
  } else {
    callback()
  }
}

export const price = (value, callback) => {
  if (value) {
    var regPos = /^\d+(\.\d+)?$/ // 非负浮点数
    if (regPos.test(value)) {
      callback()
    } else {
      return callback(new Error('请输入非负数字'))
    }
  } else {
    callback()
  }
}

/* 时间选择器 */
export const checkDate = (v, j) => {
  let startData = Date.parse(v)
  let endData = Date.parse(j)
  if (startData || endData) {
    if (!startData || !endData) {
      alert('开始时间和结束时间必须全选')
      return false
    }
    if (startData > endData) {
      alert('开始时间不能大于结束时间')
      return false
    }
  } else {
    return true
  }
}

// 字符串全是数字
export const requireNumber = (value, callback) => {
  if (value) {
    let reg = /^\d+$/
    if (reg.test(value)) {
      callback()
    } else {
      return callback(new Error('请输入数字'))
    }
  } else {
    return callback(new Error('问卷ID不能为空'))
  }
}
export const beNumber = (value, callback) => {
  if (value) {
    let reg = /^\d+$/
    if (reg.test(value)) {
      callback()
    } else {
      return callback(new Error('请输入数字'))
    }
  } else {
    callback()
  }
}

// 百分比

export const percentage = (value, callback) => {
  if (value) {
    let reg = /^\d+$/
    if (reg.test(value)) {
      if (value <= 100 && value >= 0) {
        callback()
      } else {
        return callback(new Error('请输入0到100之间的数值'))
      }
    } else {
      return callback(new Error('请输入数字'))
    }
  } else {
    callback()
  }
}

// 非特殊字符（允许大小写字母、数字、中文、下划线、减号）

export const normalString = (value, callback) => {
  if (value) {
    let reg = /^([A-Za-z0-9_\-\u4e00-\u9fa5])+$/
    if (reg.test(value)) {
      callback()
    } else {
      return callback(new Error('要求非特殊字符'))
    }
  } else {
    callback()
  }
}

// 判断输入的数字区间必须在0-30分钟

export const LimitNumberRange = (value, callback) => {
  if (value && (value > 30 || value === 0)) {
    return callback(new Error('分钟区间必须在1-30之间'))
  } else {
    callback()
  }
}

// 判断输入的数字区间必须在0-4000之内

export const restrictedNumInterval = (value, callback) => {
  if (value && (value > 4000 || value === 0)) {
    return callback(new Error('数字区间必须在1-4000之内'))
  } else {
    callback()
  }
}

// 判断输入的数字区间必须在0-100之内

export const number100 = (value, callback) => {
  if (value && (value > 100 || value < 0)) {
    return callback(new Error('数字区间必须在1-100之内'))
  } else {
    callback()
  }
}

// 判断输入是否为非负整数
export const positiveIntegerLimit = (value, callback) => {
  if (value) {
    let reg = /^[0-9]+$/
    if (reg.test(value)) {
      callback()
    } else {
      return callback(new Error('只能输入非负整数'))
    }
  } else {
    callback()
  }
}

// 验证多个用分号隔开的邮箱
export const validationEmail = (value, callback) => {
  if (value) {
    // let reg = /^((([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6}\;))*(([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})))$/
    let reg = /^((([a-z0-9_.-]+)@([da-z.-]+)\.([a-z.]{2,6};))*(([a-z0-9_.-]+)@([da-z.-]+)\.([a-z.]{2,6})))$/
    if (reg.test(value)) {
      callback()
    } else {
      callback(new Error(
        '请输入正确邮箱格式，多个邮箱需要用分号隔开，结尾不加分号'
      ))
    }
  } else {
    callback()
  }
}
// 验证最多50个用分号隔开的手机
export const phonesVerification = (value, callback) => {
  if (value) {
    let reg = /^1[3456789]\d{9}(;1[3456789]\d{9})*$/
    if (reg.test(value)) {
      let length = value.split(';').length
      if (length <= 50) {
        callback()
      } else {
        callback(new Error('最多输入50个手机号'))
      }
    } else {
      callback(new Error('请输入正确手机号，多个号码需要用分号隔开，结尾不加分号'))
    }
  } else {
    callback()
  }
}

export const validationEmailTen = (value, callback) => {
  if (value) {
    // ^((([a-z0-9_.-]+)@([da-z.-]+)\.([a-z.]{2,6};))*(([a-z0-9_.-]+)@([da-z.-]+)\.([a-z.]{2,6})))$
    let reg = /^((([a-z0-9_.-]+)@([da-z.-]+)\.([a-z.]{2,6};))*(([a-z0-9_.-]+)@([da-z.-]+)\.([a-z.]{2,6})))$/
    if (reg.test(value)) {
      let length = value.split(';').length
      if (length <= 10) {
        callback()
      } else {
        callback(new Error('最多输入10 个邮箱'))
      }
    } else {
      callback(new Error('请输入正确邮箱，多个邮箱需要用分号隔开'))
    }
  } else {
    callback()
  }
}

// 验证最多50个用逗号隔开的手机
export const phoneVerification = (value, callback) => {
  if (value) {
    let reg = /^1[3456789]\d{9}(,1[3456789]\d{9})*$/
    if (reg.test(value)) {
      let length = value.split(',').length
      if (length <= 50) {
        callback()
      } else {
        callback(new Error('最多输入50 个手机号'))
      }
    } else {
      callback(new Error('请输入正确手机号，多个手机需要用逗号隔开'))
    }
  } else {
    callback()
  }
}
// 验证最多10个用分号隔开的手机
export const phoneVerificationTen = (value, callback) => {
  if (value) {
    let reg = /^1[3456789]\d{9}(;1[3456789]\d{9})*$/
    if (reg.test(value)) {
      let length = value.split(';').length
      if (length <= 10) {
        callback()
      } else {
        callback(new Error('最多输入10 个手机号'))
      }
    } else {
      callback(new Error('请输入正确手机号，多个手机需要用分号隔开'))
    }
  } else {
    callback()
  }
}
// 多个邮件地址

export const multiEmail = (value, callback) => {
  if (value) {
    let arr = value.split(';')
    let reg = /^[A-Za-z\d]+([-_.][A-Za-z\d]+)*@([A-Za-z\d]+[-.])+[A-Za-z\d]{2,4}$/
    let regTest = arr.every(val => {
      if (val) {
        return reg.test(val)
      } else {
        return true
      }
    })
    if (regTest) {
      callback()
    } else {
      return callback(new Error('邮箱格式有误'))
    }
  } else {
    return callback(new Error('请输入邮件收件人'))
  }
}

// 验证是否有空格
export const checkBlank = (value, callback) => {
  if (value) {
    let reg = /\s/
    if (reg.test(value)) {
      return callback(new Error('输入的数据中不能有空格'))
    } else {
      callback()
    }
  } else {
    callback()
  }
}

// 验证数组是否为空
export const checkArrayLength = (value, callback) => {
  if (!value || !value.length) {
    return callback(new Error('请至少选择一个'))
  } else {
    callback()
  }
}

// 整数
export const checkInteger = (value, callback) => {
  if (!Number.isInteger(parseFloat(value))) {
    return callback(new Error('请输入整数'))
  } else {
    callback()
  }
}

// 可以是 手机号(数量不限) 和 邮箱(数量不限) 中的一种，且只能用英文 ; 分割，末尾不能是 ; 分隔符
export const checkValue = (v, callback) => {
  if (v) {
    let ary = v.split('')
    if (ary[ary.length - 1] === ';') {
      let ary2 = []
      ary2 = ary.filter((v, i, ar) => i !== ar.length - 1)
      v = ary2.join('')
    }
    let splitFirst = v.split(';')
    let flat = splitFirst[0].indexOf('@') === -1
    if (flat) {
      let phoneReg = /^1[3-578]\d{9}$/
      let num = 0
      splitFirst.forEach(e => {
        if (phoneReg.test(e)) {
          num = num + 1
        }
      })
      if (num !== splitFirst.length) {
        return callback(new Error('格式错误或分隔符错误（请用英文分号隔开）'))
      } else {
        callback()
      }
    }
    if (!flat) {
      let mailReg = /^(\w-*\.*)+@(\w-?)+(\.\w{2,})+$/
      let num = 0
      splitFirst.forEach(e => {
        if (mailReg.test(e)) {
          num = num + 1
        }
      })
      if (num !== splitFirst.length) {
        return callback(new Error('格式错误或分隔符错误（请用英文分号隔开）'))
      } else {
        callback()
      }
    }
  } else {
    return callback(new Error('此处不能为空'))
  }
}

// 校验数字和必填
export const checkNumberRequire = (value, callback) => {
  if (value) {
    if (isNaN(value)) {
      return callback(new Error('请输入数字金额'))
    } else if (value < 0) {
      return callback(new Error('金额不能为负'))
    } else {
      callback()
    }
  } else {
    return callback()
  }
}

// 校验数字和无可以为空
export const checkNumberRequire_ = (value, callback) => {
  if (value) {
    let flag = isNaN(value)
    if (!flag) {
      if (value < 0) {
        return callback(new Error('金额不能为负'))
      } else {
        callback()
      }
    }
    if (flag) {
      if (value !== '无') {
        return callback(new Error('只能填写数字和无'))
      } else {
        callback()
      }
    }
  } else if (value === 0) {
    callback()
  } else {
    callback()
  }
}